package com.thinvent.smart.chain.common;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
/**
 * 基于ConcurrentHashMap定义的本地缓存工具类
 */
public class ConcurrentHashMapLocalCacheUtil {
    // 默认大小
    private static final int DEFAULT_CAPACITY = 1024;
    // 最大缓存大小
    private static final int MAX_CAPACITY = 10000;
    // 默认缓存过期时间
//    private static final long DEFAULT_TIMEOUT = 3600;
    // 1000毫秒
    private static final long SECOND_TIME = 1000;
    // 存储缓存的Map
    private static final ConcurrentHashMap<String, Object> map;
    // 采用定时器进行定时
    private static final Timer timer;

    static {
        // 创建指定容量为DEFAULT_CAPACITY大小的ConcurrentHashMap
        map = new ConcurrentHashMap<>(DEFAULT_CAPACITY);
        // 新建定时器
        timer = new Timer();
    }
//    // 私有化构造方法
//    public ConcurrentHashMapLocalCacheUtil() {
//    }
    /**
     * 利用定时器任务类实现的缓存任务清除类
     */
    static class ClearTask extends TimerTask {
        private String key;

        public ClearTask(String key) {
            this.key = key;
        }
        @Override
        public void run() {
            ConcurrentHashMapLocalCacheUtil.remove(key);
        }
    }

    //==================缓存的增删改查========================
    /**
     * 判断容量大小
     */
    public static boolean checkCapacity() {
        return map.size() < MAX_CAPACITY;
    }

    /**
     * 添加缓存
     */
    public static boolean put(String key, Object object) {
        // 添加前先检查缓存大小
        if (checkCapacity()) {
            // 有剩余空间时存入数据
            map.put(key, object);
            // 通过定时器指定任务的默认超时时间
//            timer.schedule(new ClearTask(key), DEFAULT_TIMEOUT);
            return true;
        }
        return false;
    }

    /**
     * 可指定延时时间的添加缓存
     */
    public static boolean put(String key, Object object, int time_out) {
        // 添加前检查缓存大小
        if (checkCapacity()) {
            // 有剩余空间时存入数据
            map.put(key, object);
            // 通过定时器指定任务的超时时间
            timer.schedule(new ClearTask(key), time_out * SECOND_TIME);
            return true;
        }
        return false;
    }

    /**
     * 批量增加缓存
     */
    public static boolean put(Map<String, Object> batchMap, int time_out) {
        // 添加前检查缓存大小
        if (map.size() + batchMap.size() <= MAX_CAPACITY) {
            // 有剩余空间时存入数据
            map.putAll(map);
            // 为每个缓存添加任务及超时时间
            for (String key : batchMap.keySet()) {
                timer.schedule(new ClearTask(key), time_out * SECOND_TIME);
            }
            return true;
        }
        return false;
    }

    /**
     * 删除缓存
     */
    public static void remove(String key) {
        map.remove(key);
    }

    /**
     * 清除所有缓存
     */
    public void clearAll() {
        // 判断缓存中是否还有数据
        if (map.size() > 0) {
            // 清空map
            map.clear();
        }
        // 终止定时器
//        timer.cancel();
    }

    /**
     * 获取缓存
     */
    public static Object get(String key) {
        return map.get(key);
    }

    /**
     * 判断是否包含某个缓存
     */
    public static boolean isContain(String key) {
        return map.contains(key);
    }

}
